package generic;

import org.ietf.jgss.Oid;

import java.util.ArrayList;
import java.util.List;
//泛型类
public class Order<T> {

    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型

    T orderT;


    //异常中不能有泛型编译不通过
//        try{
//        }catch(T t){
//        }

    public Order() {
        //编译不通过
     // T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
    public /*static*/  <E> List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }

    //但是静态方法中不能使用类的泛型
//    public static void show(T t){
//
//    }
    @Override
    public String toString() {
        return "generic.Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }

}

 class SubOrder extends Order<Integer> {//generic.SubOrder:不是泛型类

     //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没任何关系。
     //换句话说，泛型方法所属的类是不是泛型类都没关系。
     @Override
    public <E> List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }
}

class test9{
    public static void main(String[] args) {
        //SubOrder不是泛型类，编译错误
//        SubOrder<Integer> o = new generic.SubOrder<>();
        SubOrder subOrder = new SubOrder();
        String[] str={"kkk","wyy"};
        List<String> list = subOrder.copyFromArrayToList(str);
        Integer[] ints={1,2,3};
        List<Integer> list1 = subOrder.copyFromArrayToList(ints);
    }
}